Higher-Order Functions and Lambdas

Higher-Order Functions and Lambdas(高阶函数和Lambdas)

目录：

1. Higher-Order Functions（高阶函数）
2. Function types（函数类型）
3. Lambda Expressions and Anonymous Functions（lambda表达式和匿名函数）

1、Higher-Order Functions（高阶函数）

高阶函数是：“将函数作为参数或返回函数”的函数

将函数作为参数的函数

fun fooFunction(bar: Int = 1, baz: Int = 1, lamb: () -> Int): Int {
    println("foo: lambda result=${lamb()}")
    return lamb()
}

返回函数的函数

fun fooFunction(a: Int): () -> Int {

    a + 1

    return fun(): Int = a
}

2、Function types（函数类型）

如同Int，String，Boolean类型一样，当函数作为参数时，也需要定义类型

kotlin使用一系列函数类型，例如(Int) -> String处理函数的声明：

//此时，(String) -> Unit 定义的onClick是一个函数，等同于：fun onClick(x:String):Unit{}
val onClick: (String) -> Unit = {

}
onClick("string")

编译器可推断变量的函数类型，如下：

val simplyFunctiontype = { x: Int, y: Int ->
    x + y
}

等同于：

val simplyFunctiontype: (Int, Int) -> Int = { x, y ->
    x + y
}

3. Lambda Expressions and Anonymous Functions（lambda表达式和匿名函数）

1. Lambda表达式和匿名函数是“函数文字”，即未声明但立即作为表达式传递的函数，

fun compare(a: String, b: String): Boolean = a.length < b.length;

2. Lambda expression syntax(Lambda表达式语法)

全部语法

/*
Lambda表达式的全部语法
*/
val sum = { x: Int, y: Int -> x + y }

lambda表达式总是被花括号括起来，完整语法形式的参数声明进入花括号内部并具有可选的类型注释，主体在->符号后面，如果lambda的推断返回类型不是Unit，则lambda主体内的最后一个（或可能是单个）表达式将被视为返回值

---

如果我们将所有可选的注释都留下，那么剩下的就是下面这样：

//Full version：Lambda expression syntax
val lambdaSumWithExplicitly: (Int, Int) -> Int = { oneParam, twoParam ->
    //lambda将最后一行表达式作为返回的值
    oneParam * twoParam
}

3. Passing a lambda to the last parameter（将lambda表达式作为函数的最后一个参数）

将Lambda表达式作为函数参数

fun fooFunction(bar: Int = 1, baz: Int = 1, lamb: () -> Int): Int {
    println("foo: lambda result=${lamb()}")
    return lamb()
}

调用带有lambda表达式参数的函数

  //括号之外传递
val lambdaParamOutResult = fooFunction {
    ""
    1
}
//括号之内传递
val lambdaParamInResult = fooFunction(lamb = {
    ""
    1
})
//括号之内传递，并且全参数赋值
val lambdaParamFullResult = fooFunction(1, 2, lamb = {
    ""
    1
})

4. it:implicit name of a single parameter（it：一个参数的隐式名称）

//it:implicit name of a single parameter
val lambdaImplicitIt: (Int) -> Int = {
    it * it
}

println("lambdaImplicitIt:${lambdaImplicitIt(5)}")//result=5*5

5. Returning a value from a lambda expression（lambda表达式返回值）

隐式返回最后一个表达式的值


    //it:implicit name of a single parameter
    val lambdaImplicitIt: (Int) -> Int = {
        val result = it * it
        result//implicit return result
    }

6. Underscope for unused variables（使用’_’作为未使用参数）

如果lambda参数未使用，则可以放置下划线代替其名称

    //使用:"_"代替未使用的参数的名称
    val lambdaProduct: (Int, Int) -> Int = { _, y ->
        y * y
    }

7. Anonymous functions（匿名函数）

匿名函数与常规函数的区别：匿名函数省略了常规函数的函数名

val anonymousFunction = fun(x: Int): Int {
    return x * x
}
println("Anonymous function:${anonymousFunction(5)}")





val anonymousFunction = fun(x: Int) = x * x
println("Anonymous function:${anonymousFunction(5)}")

8. Expansion Anonymous Function（‘拓展+匿名’的函数）

fun expansionAnonymous() {
    println();
    /*
    常规匿名函数的定义
     */
    val commonFunction = fun(num: Int): Int {
        return num * num
    }

    /*
    拓展匿名函数的定义
     */
    val expansionAnonymousFunction = fun Int.(param: Int): Int {
        return param * param
    }

    val a = 1;
    println("expansionAnonymousFunction:${a.expansionAnonymousFunction(5)}")
}

---

未完待续。。。